home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / admin / linuxcon.000 / linuxcon / linuxconf-1.6 / dnsconf / dnsconf.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-29  |  8.2 KB  |  389 lines
  1. #pragma interface
  2. #ifndef DNSCONF_H
  3. #define DNSCONF_H
  4.  
  5. #include <limits.h>
  6.  
  7. class TBFILE;
  8. class RECORD_IN_SOA;
  9. class RECORD_IN_NS;
  10. class FQHOST;
  11. class DNS;
  12. class IP_ADDRS;
  13.  
  14. #ifndef MISC_H
  15.     #include "../misc/misc.h"
  16. #endif
  17.  
  18. class IN_NAME: public SSTRING{
  19.     /*~PROTOBEG~ IN_NAME */
  20.     /*~PROTOEND~ IN_NAME */
  21. };
  22.  
  23. class IP_ADDR: public SSTRING{
  24. protected:
  25.     int a[4];    // By using int instead of unsigned char
  26.             // we can differentiate network number such as
  27.             // 10.0.0 and 10.0
  28.     /*~PROTOBEG~ IP_ADDR */
  29. public:
  30.     IP_ADDR (const IP_ADDR&adr);
  31.     IP_ADDR (const SSTRING&str);
  32.     IP_ADDR (void);
  33.     int cmp (const IP_ADDR *p);
  34.     void increm (void);
  35.     int is_valid (void);
  36.     void merge (IP_ADDR&partial);
  37.     void reformat (void);
  38.     void reverse (void);
  39.     void setfrom (const char *pt);
  40.     void setrev (char *str);
  41.     void shift (void);
  42.     void shift_right (void);
  43.     /*~PROTOEND~ IP_ADDR */
  44. };
  45.  
  46. #define MAX_SEARCH_RESOLV    6
  47. class RESOLV{
  48. public:
  49.     SSTRING domain;
  50.     SSTRING search[MAX_SEARCH_RESOLV];
  51.     IP_ADDR servers[3];
  52.     /*~PROTOBEG~ RESOLV */
  53. public:
  54.     RESOLV (void);
  55. private:
  56.     void parse (const char *pt);
  57. public:
  58.     int write (void);
  59.     /*~PROTOEND~ RESOLV */
  60. };
  61.  
  62.  
  63.  
  64. enum RECORD_TYPE{
  65.     RTYPE_COMMENT,
  66.     RTYPE_SOA,
  67.     RTYPE_A,
  68.     RTYPE_PTR,
  69.     RTYPE_NS,
  70.     RTYPE_MX,
  71.     RTYPE_CNAME,
  72.     RTYPE_INCLUDE,
  73.     RTYPE_END_INCLUDE,
  74.     RTYPE_ORIGIN
  75. };
  76.  
  77. class RECORD: public ARRAY_OBJ{
  78. public:
  79.     RECORD_TYPE id;        // Used by the function is() to identify
  80.                 // the type of a record
  81.     SSTRING comment;
  82.     virtual void edit()=0;
  83.     //virtual IP_ADDR *getip()const =0;
  84.     //virtual IN_NAME *getname() const =0;
  85.     virtual void print (FILE *fout) const =0;
  86.     /*~PROTOBEG~ RECORD */
  87. public:
  88.     RECORD (RECORD_TYPE _id);
  89.     int cmp (RECORD *other);
  90.     virtual int cmp_left (const char *);
  91. protected:
  92.     virtual int cmpsame (const RECORD *);
  93. public:
  94.     bool is (RECORD_TYPE _id);
  95.     virtual int set (const RECORD *);
  96.     void setcomment (const char *str);
  97.     virtual void sethostpart (const char *);
  98.     /*~PROTOEND~ RECORD */
  99. };
  100.  
  101. class RECORD_COMMENT: public RECORD{
  102.     /*~PROTOBEG~ RECORD_COMMENT */
  103. public:
  104.     RECORD_COMMENT (const char *str);
  105.     void edit (void);
  106.     void print (FILE *fout)const;
  107.     /*~PROTOEND~ RECORD_COMMENT */
  108. };
  109.  
  110. class RECORD_PARSE;
  111.  
  112. class RECORD_IN: public RECORD{
  113. protected:
  114.     long ttl;
  115.     char nottl;    // Is there a ttl field
  116.     char ttlstr[20];
  117.     /*~PROTOBEG~ RECORD_IN */
  118. public:
  119.     RECORD_IN (RECORD_TYPE _id);
  120.     RECORD_IN (const RECORD_PARSE&p, RECORD_TYPE _id);
  121.     /*~PROTOEND~ RECORD_IN */
  122. };
  123.  
  124. class RECORD_IN_A: public RECORD_IN{
  125. public:
  126.     IN_NAME name;
  127.     IP_ADDR addr;
  128.     /*~PROTOBEG~ RECORD_IN_A */
  129. public:
  130.     RECORD_IN_A (const RECORD_PARSE&p);
  131.     RECORD_IN_A (const char *_name, const char *_addr);
  132. protected:
  133.     int cmp_left (const char *str);
  134. public:
  135.     int cmphost (const char *host);
  136. protected:
  137.     int cmpsame (const RECORD *other);
  138. public:
  139.     void edit (void);
  140.     void print (FILE *fout)const;
  141.     int set (const RECORD *other);
  142.     void sethostpart (const char *hostpart);
  143.     void setip (const char *ip);
  144.     /*~PROTOEND~ RECORD_IN_A */
  145. };
  146. class RECORD_IN_PTR: public RECORD_IN{
  147.     IN_NAME name;
  148.     IN_NAME addr;
  149.     /*~PROTOBEG~ RECORD_IN_PTR */
  150. public:
  151.     RECORD_IN_PTR (const RECORD_PARSE&p);
  152.     RECORD_IN_PTR (const char *iprev,
  153.          const char *host);
  154. protected:
  155.     int cmp_left (const char *str);
  156. public:
  157.     int cmpip (const char *ip);
  158. protected:
  159.     int cmpsame (const RECORD *other);
  160. public:
  161.     void edit (void);
  162.     void print (FILE *fout)const;
  163.     int set (const RECORD *other);
  164.     void sethostpart (const char *hostpart);
  165.     /*~PROTOEND~ RECORD_IN_PTR */
  166. };
  167.  
  168. class RECORDS: public ARRAY{
  169.     /*~PROTOBEG~ RECORDS */
  170. public:
  171.     RECORD *getitem (int no)const;
  172.     int save (TBFILE&tbf)const;
  173.     /*~PROTOEND~ RECORDS */
  174. };
  175.  
  176. class ORIGIN: public ARRAY_OBJ{
  177. public:
  178.     SSTRING origin;
  179.     RECORDS tbrec;
  180.     /*~PROTOBEG~ ORIGIN */
  181. public:
  182.     ORIGIN (const char *_origin);
  183.     void edit (void);
  184.     int getalladr (IP_ADDRS&adrs);
  185.     void print (bool save_ori, TBFILE&tbf)const;
  186.     int was_modified (void);
  187.     /*~PROTOEND~ ORIGIN */
  188. };
  189.  
  190. class ORIGINS: public ARRAY{
  191.     /*~PROTOBEG~ ORIGINS */
  192. public:
  193.     ORIGIN *getitem (int no)const;
  194. private:
  195.     int parseend (char *pt,
  196.          RECORD_PARSE&p,
  197.          ORIGIN *ori);
  198.     int parsespecial (const char *key,
  199.          const char *pt,
  200.          TBFILE&tbf,
  201.          ORIGIN *&ori);
  202. public:
  203.     int read (const char *named_dir,
  204.          const char *fname,
  205.          const char *first_origin);
  206.     int save (const char *named_dir,
  207.          const char *fname)const;
  208.     /*~PROTOEND~ ORIGINS */
  209. };
  210.  
  211. class PRIMARY: public ARRAY_OBJ{
  212. public:
  213.     SSTRING domain;
  214.     SSTRING domainv;    // Use to present the domain
  215.                 // to the user, differ from domain
  216.                 // only for reverse mapping .. so far
  217.     SSTRING file;
  218.     ORIGINS origins;    // origins->getitem(0) is set by default
  219.                 // to the domain.
  220.     char isrev;        // Tell if it is a domain or reverse
  221.                 // mapping primary.
  222.     /*~PROTOBEG~ PRIMARY */
  223. public:
  224.     PRIMARY (const char *_domain,
  225.          const char *_file,
  226.          const char *named_dir);
  227.     PRIMARY (void);
  228.     void addrec (RECORD *rec);
  229.     int edit (DNS&dns);
  230.     int geta (SSTRING&dom, IP_ADDRS&adrs);
  231.     int geta (SSTRING&dom, RECORDS&recs);
  232.     int getalladr (IP_ADDRS&adrs);
  233.     int getcname (SSTRING&dom, SSTRING&cname);
  234. private:
  235.     RECORD *getfirst (RECORD_TYPE rtype);
  236. public:
  237.     int getmx (SSTRING&dom, RECORDS&recs);
  238.     int getmx (SSTRING&dom, SSTRINGS&strs);
  239.     int getns (SSTRING&dom, RECORDS&recs);
  240.     int getns (SSTRING&dom, SSTRINGS&strs);
  241. protected:
  242.     RECORD_IN_SOA *getsoa (void);
  243. public:
  244.     virtual int is_reverse (void);
  245.     int locate_left (FQHOST&fq,
  246.          RECORD_TYPE rtype,
  247.          RECORDS&recs);
  248.     int set (FQHOST&fq, RECORD *new_rec);
  249.     virtual void setfromv (void);
  250.     int unset (RECORD *new_rec);
  251.     void updatesoa (void);
  252.     int was_modified (void);
  253.     int write (FILE *fout, const char *named_dir)const;
  254.     /*~PROTOEND~ PRIMARY */
  255. };
  256.  
  257. class PRIMARY_REV: public PRIMARY{
  258. public:
  259.     /*~PROTOBEG~ PRIMARY_REV */
  260. public:
  261.     PRIMARY_REV (const char *_domain,
  262.          const char *_file,
  263.          const char *named_dir);
  264.     PRIMARY_REV (void);
  265.     int is_reverse (void);
  266.     void setfromv (void);
  267.     /*~PROTOEND~ PRIMARY_REV */
  268. };
  269.  
  270.  
  271. class PRIMARYS: public ARRAY{
  272.     /*~PROTOBEG~ PRIMARYS */
  273. public:
  274.     void edit (DNS&dns);
  275.     int getalladr (IP_ADDRS&adrs);
  276.     PRIMARY *getitem (FQHOST&fq,
  277.          char *hostpart,
  278.          int dontitself);
  279.     PRIMARY *getitem (FQHOST&fq, char *hostpart);
  280.     PRIMARY *getitem (int no)const;
  281.     virtual PRIMARY *new_PRIMARY (void);
  282.     int write (FILE *fout, const char *named_dir)const;
  283.     /*~PROTOEND~ PRIMARYS */
  284. };
  285. class PRIMARYS_REV: public PRIMARYS{
  286.     /*~PROTOBEG~ PRIMARYS_REV */
  287. public:
  288.     PRIMARY *new_PRIMARY (void);
  289.     /*~PROTOEND~ PRIMARYS_REV */
  290. };
  291.  
  292. class SECONDARY: public ARRAY_OBJ{
  293. public:
  294.     SSTRING domain;
  295.     IP_ADDR addr[4];
  296.     SSTRING backup;
  297.     /*~PROTOBEG~ SECONDARY */
  298. public:
  299.     SECONDARY (const char *_domain,
  300.          const char *_backup,
  301.          const char **_ip_addr,
  302.          int nb_ip);
  303.     SECONDARY (void);
  304.     int edit (void);
  305.     void write (FILE *fout, const char *named_dir)const;
  306.     /*~PROTOEND~ SECONDARY */
  307. };
  308.  
  309. class SECONDARYS: public ARRAY{
  310.     /*~PROTOBEG~ SECONDARYS */
  311. public:
  312.     void edit (DNS&dns);
  313.     SECONDARY *getitem (int no)const;
  314.     void write (FILE *fout,
  315.          const char *named_dir)const;
  316.     /*~PROTOEND~ SECONDARYS */
  317. };
  318.  
  319. class CACHEFILE: public ARRAY_OBJ{
  320. public:
  321.     SSTRING domain;
  322.     SSTRING path;
  323.     /*~PROTOBEG~ CACHEFILE */
  324. public:
  325.     CACHEFILE (const char *_domain, const char *_path);
  326.     /*~PROTOEND~ CACHEFILE */
  327. };
  328. class CACHEFILES: public ARRAY{
  329. public:
  330.     /*~PROTOBEG~ CACHEFILES */
  331. public:
  332.     CACHEFILE *getitem (int no);
  333.     /*~PROTOEND~ CACHEFILES */
  334. };
  335.  
  336. /* #Specification: dnsconf / forwarders / number of
  337.     dnsconf arbitrarily limit the number of forwarders to 5.
  338. */
  339. #define MAX_FORWARDERS    5
  340.  
  341. class DNS: public ARRAY_OBJ{
  342.     SSTRING pathcfg;
  343.     CACHEFILES cachefiles;
  344.     PRIMARYS primarys;
  345.     PRIMARYS_REV primarys_rev;
  346.     SECONDARYS secondarys;
  347.     IP_ADDR forwarders[MAX_FORWARDERS];
  348.     int nbforward;
  349.     char slave;
  350.     /*~PROTOBEG~ DNS */
  351. public:
  352.     DNS (void);
  353.     void basiccheck (void);
  354.     void check (void);
  355.     void edit (void);
  356.     void editforwarders (void);
  357.     void editmxs (void);
  358.     void editrecs (const char *name);
  359.     void editrecs (void);
  360.     int empty (void);
  361. private:
  362.     void parse (const char *buf,
  363.          const char *fpath,
  364.          int noline);
  365. public:
  366.     int set (const char *fqhost,
  367.          const char *tbip[],
  368.          int nbip);
  369.     void setcname (const SSTRING&fqhost,
  370.          const SSTRING&cname);
  371.     void setlocalhost (void);
  372.     int setmx (const SSTRING&fqhost, const SSTRINGS&tbmx);
  373.     int setns (const SSTRING&fqhost, const SSTRINGS&tbns);
  374.     void unset (const char *fqhost);
  375.     void unsetmx (const SSTRING&fqhost);
  376.     void unsetns (const SSTRING&fqhost);
  377.     int was_modified (void);
  378.     int write (void);
  379.     /*~PROTOEND~ DNS */
  380. };
  381.     
  382.  
  383.  
  384.  
  385. #include "dnsconf.p"
  386.  
  387. #endif
  388.  
  389.